{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time Series Forecasting Metrics\n",
    "\n",
    "In time series forecasting, evaluating the performance of predictive models is crucial to ensure accurate and reliable forecasts. Forecasting metrics are quantitative measures used to assess the accuracy and effectiveness of these models. They help in comparing different models, diagnosing errors, and making informed decisions based on forecast results.\n",
    "\n",
    "Skforecast is compatible with most of the regression metrics from scikit-learn and includes additional metrics specifically designed for time series forecasting.\n",
    "\n",
    "+ Mean Squared Error ([`mean_squared_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html))\n",
    "\n",
    "+ Mean Absolute Error ([`mean_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_error.html))\n",
    "\n",
    "+ Mean Absolute Percentage Error ([`mean_absolute_percentage_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_absolute_percentage_error.html))\n",
    "\n",
    "+ Symmetric Mean Absolute Percentage Error ([`symmetric_mean_absolute_percentage_error`](https://en.wikipedia.org/wiki/Symmetric_mean_absolute_percentage_error))\n",
    "\n",
    "+ Mean Squared Log Error ([`mean_squared_log_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_log_error.html))\n",
    "\n",
    "+ Median Absolute Error ([`median_absolute_error`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.median_absolute_error.html))\n",
    "\n",
    "+ Mean Absolute Scaled Error ([`mean_absolute_scaled_error`](https://en.wikipedia.org/wiki/Mean_absolute_scaled_error#:~:text=In%20statistics%2C%20the%20mean%20absolute,2005%20by%20statistician%20Rob%20J.))\n",
    "\n",
    "+ Root Mean Squared Scaled Error (`root_mean_squared_scaled_error`)\n",
    "\n",
    "In addition, Skforecast allows the user to define their own custom metrics. This can be done by creating a function that takes two arguments: the true values (`y_true`) and the predicted values (`y_pred`), and returns a single value representing the metric. The custom metric, optionally takes an additional argument `y_train` with the training data used to fit the model.\n",
    "\n",
    "In most cases, the metrics are calculated using the predictions generated in a [backtesting](../user_guides/backtesting.html) process. For this, the `backtesting_forecaster` and `backtesting_forecaster_multiseries` functions take the `metrics` argument to specify the metric(s) to be calculated in addition to the predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metrics for single series forecasting\n",
    "\n",
    "The following code shows how to calculate metrics when a single series is forecasted. The example uses the `backtesting_forecaster` function to generate predictions and calculate the metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "# ==============================================================================\n",
    "import pandas as pd\n",
    "from lightgbm import LGBMRegressor\n",
    "from skforecast.datasets import fetch_dataset\n",
    "from skforecast.recursive import ForecasterRecursive\n",
    "from skforecast.model_selection import TimeSeriesFold, backtesting_forecaster\n",
    "from sklearn.metrics import mean_squared_error, mean_absolute_percentage_error, mean_absolute_error\n",
    "from skforecast.metrics import mean_absolute_scaled_error\n",
    "from skforecast.plot import set_dark_theme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">╭───────────────────────────── <span style=\"font-weight: bold\">website_visits</span> ──────────────────────────────╮\n",
       "│ <span style=\"font-weight: bold\">Description:</span>                                                              │\n",
       "│ Daily visits to the cienciadedatos.net website registered with the google │\n",
       "│ analytics service.                                                        │\n",
       "│                                                                           │\n",
       "│ <span style=\"font-weight: bold\">Source:</span>                                                                   │\n",
       "│ Amat Rodrigo, J. (2021). cienciadedatos.net (1.0.0). Zenodo.              │\n",
       "│ https://doi.org/10.5281/zenodo.10006330                                   │\n",
       "│                                                                           │\n",
       "│ <span style=\"font-weight: bold\">URL:</span>                                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                  │\n",
       "│ datasets/main/data/visitas_por_dia_web_cienciadedatos.csv                 │\n",
       "│                                                                           │\n",
       "│ <span style=\"font-weight: bold\">Shape:</span> 421 rows x 2 columns                                               │\n",
       "╰───────────────────────────────────────────────────────────────────────────╯\n",
       "</pre>\n"
      ],
      "text/plain": [
       "╭───────────────────────────── \u001b[1mwebsite_visits\u001b[0m ──────────────────────────────╮\n",
       "│ \u001b[1mDescription:\u001b[0m                                                              │\n",
       "│ Daily visits to the cienciadedatos.net website registered with the google │\n",
       "│ analytics service.                                                        │\n",
       "│                                                                           │\n",
       "│ \u001b[1mSource:\u001b[0m                                                                   │\n",
       "│ Amat Rodrigo, J. (2021). cienciadedatos.net (1.0.0). Zenodo.              │\n",
       "│ https://doi.org/10.5281/zenodo.10006330                                   │\n",
       "│                                                                           │\n",
       "│ \u001b[1mURL:\u001b[0m                                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-                  │\n",
       "│ datasets/main/data/visitas_por_dia_web_cienciadedatos.csv                 │\n",
       "│                                                                           │\n",
       "│ \u001b[1mShape:\u001b[0m 421 rows x 2 columns                                               │\n",
       "╰───────────────────────────────────────────────────────────────────────────╯\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>users</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-07-01</th>\n",
       "      <td>2324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-07-02</th>\n",
       "      <td>2201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-07-03</th>\n",
       "      <td>2146</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            users\n",
       "date             \n",
       "2020-07-01   2324\n",
       "2020-07-02   2201\n",
       "2020-07-03   2146"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dowlnoad dataset\n",
    "# ==============================================================================\n",
    "data = fetch_dataset('website_visits', raw=True)\n",
    "data['date'] = pd.to_datetime(data['date'], format='%d/%m/%y')\n",
    "data = data.set_index('date')\n",
    "data = data.asfreq('1D')\n",
    "data = data.sort_index()\n",
    "data.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "31ea52f0669d41df98a16f0d214a1508",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/31 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean_absolute_error</th>\n",
       "      <th>mean_squared_error</th>\n",
       "      <th>mean_absolute_percentage_error</th>\n",
       "      <th>mean_absolute_scaled_error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>298.298903</td>\n",
       "      <td>165698.930884</td>\n",
       "      <td>0.176136</td>\n",
       "      <td>0.695103</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   mean_absolute_error  mean_squared_error  mean_absolute_percentage_error  \\\n",
       "0           298.298903       165698.930884                        0.176136   \n",
       "\n",
       "   mean_absolute_scaled_error  \n",
       "0                    0.695103  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Backtesting to generate predictions over the test set and calculate metrics\n",
    "# ==============================================================================\n",
    "forecaster = ForecasterRecursive(\n",
    "                 estimator = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags      = 7\n",
    "             )\n",
    "\n",
    "metrics = [\n",
    "    'mean_absolute_error',\n",
    "    'mean_squared_error',\n",
    "    'mean_absolute_percentage_error',\n",
    "    'mean_absolute_scaled_error'\n",
    "]\n",
    "\n",
    "cv = TimeSeriesFold(steps=7, initial_train_size = len(data) // 2)\n",
    "\n",
    "backtest_metrics, predictions = backtesting_forecaster(\n",
    "                                    forecaster = forecaster,\n",
    "                                    y          = data['users'],\n",
    "                                    cv         = cv,\n",
    "                                    metric     = metrics,\n",
    "                                )\n",
    "backtest_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to pass a list of functions instead of names. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7019939386c54583aed4a24d37fe939f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/31 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean_absolute_error</th>\n",
       "      <th>mean_squared_error</th>\n",
       "      <th>mean_absolute_percentage_error</th>\n",
       "      <th>mean_absolute_scaled_error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>298.298903</td>\n",
       "      <td>165698.930884</td>\n",
       "      <td>0.176136</td>\n",
       "      <td>0.695103</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   mean_absolute_error  mean_squared_error  mean_absolute_percentage_error  \\\n",
       "0           298.298903       165698.930884                        0.176136   \n",
       "\n",
       "   mean_absolute_scaled_error  \n",
       "0                    0.695103  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Backtesting with callable metrics\n",
    "# ==============================================================================\n",
    "metrics = [\n",
    "    mean_absolute_error,\n",
    "    mean_squared_error,\n",
    "    mean_absolute_percentage_error,\n",
    "    mean_absolute_scaled_error\n",
    "]\n",
    "\n",
    "backtest_metrics, predictions = backtesting_forecaster(\n",
    "                                    forecaster = forecaster,\n",
    "                                    y          = data['users'],\n",
    "                                    cv         = cv,\n",
    "                                    metric     = metrics,\n",
    "                                )\n",
    "backtest_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since functions can be passed as arguments, it is possible to define custom metrics. The custom metric must be a function that takes two arguments: the true values (`y_true`) and the predicted values (`y_pred`), and returns a single value representing the metric. Optionally, it can take additional arguments `y_train` with the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1fc95f803a2747f4a7714c854a955391",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/31 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>custom_metric</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>298.375447</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   custom_metric\n",
       "0     298.375447"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Backtesting with custom metric\n",
    "# ==============================================================================\n",
    "def custom_metric(y_true, y_pred):\n",
    "    \"\"\"\n",
    "    Calculate the mean absolute error excluding weekends.\n",
    "    \"\"\"\n",
    "    mask = y_true.index.weekday < 5\n",
    "    metric = mean_absolute_error(y_true[mask], y_pred[mask])\n",
    "\n",
    "    return metric\n",
    "\n",
    "\n",
    "backtest_metrics, predictions = backtesting_forecaster(\n",
    "                                    forecaster = forecaster,\n",
    "                                    y          = data['users'],\n",
    "                                    cv         = cv,\n",
    "                                    metric     = custom_metric,\n",
    "                                )\n",
    "backtest_metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metrics for multiple time series forecasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with multiple time series, it is common to calculate metrics across all series to get an overall measure of performance, in addition to individual values. Skforecast provides 3 different aggregation methods:\n",
    "\n",
    "+ **average**: the average (arithmetic mean) of all levels.\n",
    "\n",
    "+ **weighted_average**: the average of the metrics weighted by the number of predicted values of each level.\n",
    "\n",
    "+ **pooling**: the values of all levels are pooled and then the metric is calculated.\n",
    "\n",
    "To include the aggregated metrics in the output of `backtesting_forecaster_multiseries`, the `add_aggregated_metric` argument must be set to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries\n",
    "# ==============================================================================\n",
    "import matplotlib.pyplot as plt\n",
    "from lightgbm import LGBMRegressor\n",
    "from skforecast.datasets import fetch_dataset\n",
    "from skforecast.recursive import ForecasterRecursiveMultiSeries\n",
    "from skforecast.model_selection import backtesting_forecaster_multiseries\n",
    "from skforecast.model_selection import grid_search_forecaster_multiseries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">╭─────────────────────── <span style=\"font-weight: bold\">items_sales</span> ───────────────────────╮\n",
       "│ <span style=\"font-weight: bold\">Description:</span>                                              │\n",
       "│ Simulated time series for the sales of 3 different items. │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">Source:</span>                                                   │\n",
       "│ Simulated data.                                           │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">URL:</span>                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-  │\n",
       "│ datasets/main/data/simulated_items_sales.csv              │\n",
       "│                                                           │\n",
       "│ <span style=\"font-weight: bold\">Shape:</span> 1097 rows x 3 columns                              │\n",
       "╰───────────────────────────────────────────────────────────╯\n",
       "</pre>\n"
      ],
      "text/plain": [
       "╭─────────────────────── \u001b[1mitems_sales\u001b[0m ───────────────────────╮\n",
       "│ \u001b[1mDescription:\u001b[0m                                              │\n",
       "│ Simulated time series for the sales of 3 different items. │\n",
       "│                                                           │\n",
       "│ \u001b[1mSource:\u001b[0m                                                   │\n",
       "│ Simulated data.                                           │\n",
       "│                                                           │\n",
       "│ \u001b[1mURL:\u001b[0m                                                      │\n",
       "│ https://raw.githubusercontent.com/skforecast/skforecast-  │\n",
       "│ datasets/main/data/simulated_items_sales.csv              │\n",
       "│                                                           │\n",
       "│ \u001b[1mShape:\u001b[0m 1097 rows x 3 columns                              │\n",
       "╰───────────────────────────────────────────────────────────╯\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>item_1</th>\n",
       "      <th>item_2</th>\n",
       "      <th>item_3</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-01-01</th>\n",
       "      <td>8.253175</td>\n",
       "      <td>21.047727</td>\n",
       "      <td>19.429739</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-02</th>\n",
       "      <td>22.777826</td>\n",
       "      <td>26.578125</td>\n",
       "      <td>28.009863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-03</th>\n",
       "      <td>27.549099</td>\n",
       "      <td>31.751042</td>\n",
       "      <td>32.078922</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-04</th>\n",
       "      <td>25.895533</td>\n",
       "      <td>24.567708</td>\n",
       "      <td>27.252276</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-01-05</th>\n",
       "      <td>21.379238</td>\n",
       "      <td>18.191667</td>\n",
       "      <td>20.357737</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               item_1     item_2     item_3\n",
       "date                                       \n",
       "2012-01-01   8.253175  21.047727  19.429739\n",
       "2012-01-02  22.777826  26.578125  28.009863\n",
       "2012-01-03  27.549099  31.751042  32.078922\n",
       "2012-01-04  25.895533  24.567708  27.252276\n",
       "2012-01-05  21.379238  18.191667  20.357737"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Data download\n",
    "# ==============================================================================\n",
    "data = fetch_dataset(name=\"items_sales\")\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dates : 2012-01-01 00:00:00 --- 2014-07-15 00:00:00   (n=927)\n",
      "Test dates  : 2014-07-16 00:00:00 --- 2015-01-01 00:00:00   (n=170)\n"
     ]
    }
   ],
   "source": [
    "# Split data into train-val-test\n",
    "# ==============================================================================\n",
    "end_train = '2014-07-15 23:59:00'\n",
    "data_train = data.loc[:end_train, :].copy()\n",
    "data_test  = data.loc[end_train:, :].copy()\n",
    "\n",
    "print(\n",
    "    f\"Train dates : {data_train.index.min()} --- {data_train.index.max()}   \"\n",
    "    f\"(n={len(data_train)})\"\n",
    ")\n",
    "print(\n",
    "    f\"Test dates  : {data_test.index.min()} --- {data_test.index.max()}   \"\n",
    "    f\"(n={len(data_test)})\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot time series\n",
    "# ==============================================================================\n",
    "set_dark_theme()\n",
    "fig, axes = plt.subplots(nrows=3, ncols=1, figsize=(7, 5), sharex=True)\n",
    "for i, item in enumerate(['item_1', 'item_2', 'item_3'], start=0):\n",
    "    data_train[item].plot(label='train', ax=axes[i])\n",
    "    data_test[item].plot(label='test', ax=axes[i])\n",
    "    axes[i].set_ylabel('sales')\n",
    "    axes[i].set_title(f'Item {i + 1}')\n",
    "    axes[i].set_xlabel('')\n",
    "    axes[i].legend(loc='upper left')\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create and fit a Forecaster Multi-Series\n",
    "# ==============================================================================\n",
    "forecaster = ForecasterRecursiveMultiSeries(\n",
    "                 estimator = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags      = 24,\n",
    "                 encoding  = 'ordinal'\n",
    "             )\n",
    "forecaster.fit(series=data_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "85a57b5b9f584f3aaa3daa4a0ab94af0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Backtest metrics\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>levels</th>\n",
       "      <th>mean_absolute_error</th>\n",
       "      <th>mean_squared_error</th>\n",
       "      <th>mean_absolute_percentage_error</th>\n",
       "      <th>mean_absolute_scaled_error</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>item_1</td>\n",
       "      <td>1.163837</td>\n",
       "      <td>2.748612</td>\n",
       "      <td>0.057589</td>\n",
       "      <td>0.762485</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>item_2</td>\n",
       "      <td>2.634182</td>\n",
       "      <td>12.358668</td>\n",
       "      <td>0.171335</td>\n",
       "      <td>1.118262</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>item_3</td>\n",
       "      <td>3.111351</td>\n",
       "      <td>16.096772</td>\n",
       "      <td>0.200664</td>\n",
       "      <td>0.840188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>average</td>\n",
       "      <td>2.303123</td>\n",
       "      <td>10.401350</td>\n",
       "      <td>0.143196</td>\n",
       "      <td>0.906978</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>weighted_average</td>\n",
       "      <td>2.303123</td>\n",
       "      <td>10.401350</td>\n",
       "      <td>0.143196</td>\n",
       "      <td>0.906978</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>pooling</td>\n",
       "      <td>2.303123</td>\n",
       "      <td>10.401350</td>\n",
       "      <td>0.143196</td>\n",
       "      <td>0.910909</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             levels  mean_absolute_error  mean_squared_error  \\\n",
       "0            item_1             1.163837            2.748612   \n",
       "1            item_2             2.634182           12.358668   \n",
       "2            item_3             3.111351           16.096772   \n",
       "3           average             2.303123           10.401350   \n",
       "4  weighted_average             2.303123           10.401350   \n",
       "5           pooling             2.303123           10.401350   \n",
       "\n",
       "   mean_absolute_percentage_error  mean_absolute_scaled_error  \n",
       "0                        0.057589                    0.762485  \n",
       "1                        0.171335                    1.118262  \n",
       "2                        0.200664                    0.840188  \n",
       "3                        0.143196                    0.906978  \n",
       "4                        0.143196                    0.906978  \n",
       "5                        0.143196                    0.910909  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Backtesting forecaster on multiple time series\n",
    "# ==============================================================================\n",
    "metrics = [\n",
    "    'mean_absolute_error',\n",
    "    'mean_squared_error',\n",
    "    'mean_absolute_percentage_error',\n",
    "    'mean_absolute_scaled_error'\n",
    "]\n",
    "\n",
    "cv = TimeSeriesFold(steps=24, initial_train_size=len(data_train))\n",
    "\n",
    "backtest_metrics, backtest_predictions = backtesting_forecaster_multiseries(\n",
    "    forecaster            = forecaster,\n",
    "    series                = data,\n",
    "    cv                    = cv,\n",
    "    levels                = None,\n",
    "    metric                = metrics,\n",
    "    add_aggregated_metric = True\n",
    ")\n",
    "\n",
    "print(\"Backtest metrics\")\n",
    "backtest_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Backtest predictions\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>level</th>\n",
       "      <th>fold</th>\n",
       "      <th>pred</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2014-07-16</th>\n",
       "      <td>item_1</td>\n",
       "      <td>0</td>\n",
       "      <td>25.906323</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-07-16</th>\n",
       "      <td>item_2</td>\n",
       "      <td>0</td>\n",
       "      <td>10.522491</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-07-16</th>\n",
       "      <td>item_3</td>\n",
       "      <td>0</td>\n",
       "      <td>12.034587</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2014-07-17</th>\n",
       "      <td>item_1</td>\n",
       "      <td>0</td>\n",
       "      <td>25.807194</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             level  fold       pred\n",
       "2014-07-16  item_1     0  25.906323\n",
       "2014-07-16  item_2     0  10.522491\n",
       "2014-07-16  item_3     0  12.034587\n",
       "2014-07-17  item_1     0  25.807194"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Backtest predictions\n",
    "# ==============================================================================\n",
    "print(\"Backtest predictions\")\n",
    "backtest_predictions.head(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using the hyperparameter optimization functions, the metrics are computed for each level and then aggregated. The `aggregate_metric` argument determines the aggregation method(s) to be used. Some considerations when choosing the aggregation method are:\n",
    "\n",
    "+ 'average' and 'weighted_average' will be different if the number of predicted values is different for each series (level).\n",
    "\n",
    "+ When all series have the same number of predicted values, 'average', 'weighted_average' and 'pooling' are equivalent except for the case of scaled metrics (`mean_absolute_scaled_error`, `root_mean_squared_scaled_error`) as the naive forecast is calculated individually for each series.\n",
    "\n",
    "In this example, `metric = ['mean_absolute_scaled_error', 'root_mean_squared_scaled_error']` and `aggregate_metric = ['weighted_average', 'average', 'pooling']` so that the following metrics are calculated:\n",
    "\n",
    "+ mean_absolute_scaled_error__weighted_average, mean_absolute_scaled_error__average, mean_absolute_scaled_error__pooling\n",
    "\n",
    "+ root_mean_squared_scaled_error__weighted_average, root_mean_squared_scaled_error__average, root_mean_squared_scaled_error__pooling\n",
    "\n",
    "Since `return_best` is set to `True`, the best model is returned. The best model is the one that minimizes the metric obtained by the first specified metric and aggregation method, `mean_absolute_scaled_error__weighted_average`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╭────────────────────────────────── InputTypeWarning ──────────────────────────────────╮</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Passing a DataFrame (either wide or long format) as `series` requires additional     <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> internal transformations, which can increase computational time. It is recommended   <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> to use a dictionary of pandas Series instead. For more details, see:                 <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> html#input-data                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>                                                                                      <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Category : skforecast.exceptions.InputTypeWarning                                    <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Location :                                                                           <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> tils.py:2349                                                                         <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span> Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                <span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">│</span>\n",
       "<span style=\"color: #ffaf00; text-decoration-color: #ffaf00\">╰──────────────────────────────────────────────────────────────────────────────────────╯</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[38;5;214m╭─\u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m InputTypeWarning \u001b[0m\u001b[38;5;214m─────────────────────────────────\u001b[0m\u001b[38;5;214m─╮\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Passing a DataFrame (either wide or long format) as `series` requires additional     \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m internal transformations, which can increase computational time. It is recommended   \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m to use a dictionary of pandas Series instead. For more details, see:                 \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m https://skforecast.org/latest/user_guides/independent-multi-time-series-forecasting. \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m html#input-data                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m                                                                                      \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Category : skforecast.exceptions.InputTypeWarning                                    \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Location :                                                                           \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m c:\\Users\\jaesc2\\Miniconda3\\envs\\skforecast_py12\\Lib\\site-packages\\skforecast\\utils\\u \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m tils.py:2349                                                                         \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m│\u001b[0m Suppress : warnings.simplefilter('ignore', category=InputTypeWarning)                \u001b[38;5;214m│\u001b[0m\n",
       "\u001b[38;5;214m╰──────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62ed146b6aa94037b3838f47bffaf17b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "lags grid:   0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ecc8960a57c8416c88f025250a4f47dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "params grid:   0%|          | 0/4 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`Forecaster` refitted using the best-found lags and parameters, and the whole data set: \n",
      "  Lags: [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24\n",
      " 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48] \n",
      "  Parameters: {'max_depth': 7, 'n_estimators': 20}\n",
      "  Backtesting metric: 0.8965371058488802\n",
      "  Levels: ['item_1', 'item_2', 'item_3']\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>levels</th>\n",
       "      <th>lags</th>\n",
       "      <th>lags_label</th>\n",
       "      <th>params</th>\n",
       "      <th>mean_absolute_scaled_error__weighted_average</th>\n",
       "      <th>mean_absolute_scaled_error__average</th>\n",
       "      <th>mean_absolute_scaled_error__pooling</th>\n",
       "      <th>root_mean_squared_scaled_error__weighted_average</th>\n",
       "      <th>root_mean_squared_scaled_error__average</th>\n",
       "      <th>root_mean_squared_scaled_error__pooling</th>\n",
       "      <th>max_depth</th>\n",
       "      <th>n_estimators</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 7, 'n_estimators': 20}</td>\n",
       "      <td>0.896537</td>\n",
       "      <td>0.896537</td>\n",
       "      <td>0.891585</td>\n",
       "      <td>0.873490</td>\n",
       "      <td>0.873490</td>\n",
       "      <td>0.862816</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 3, 'n_estimators': 20}</td>\n",
       "      <td>0.968697</td>\n",
       "      <td>0.968697</td>\n",
       "      <td>0.946763</td>\n",
       "      <td>0.927639</td>\n",
       "      <td>0.927639</td>\n",
       "      <td>0.896254</td>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 7, 'n_estimators': 20}</td>\n",
       "      <td>0.970085</td>\n",
       "      <td>0.970085</td>\n",
       "      <td>0.962275</td>\n",
       "      <td>0.930273</td>\n",
       "      <td>0.930273</td>\n",
       "      <td>0.921523</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 3, 'n_estimators': 20}</td>\n",
       "      <td>0.992591</td>\n",
       "      <td>0.992591</td>\n",
       "      <td>0.971936</td>\n",
       "      <td>0.937760</td>\n",
       "      <td>0.937760</td>\n",
       "      <td>0.910280</td>\n",
       "      <td>3</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 7, 'n_estimators': 10}</td>\n",
       "      <td>1.295626</td>\n",
       "      <td>1.295626</td>\n",
       "      <td>1.213049</td>\n",
       "      <td>1.172435</td>\n",
       "      <td>1.172435</td>\n",
       "      <td>1.077139</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 3, 'n_estimators': 10}</td>\n",
       "      <td>1.369425</td>\n",
       "      <td>1.369425</td>\n",
       "      <td>1.292356</td>\n",
       "      <td>1.237487</td>\n",
       "      <td>1.237487</td>\n",
       "      <td>1.143031</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 3, 'n_estimators': 10}</td>\n",
       "      <td>1.378819</td>\n",
       "      <td>1.378819</td>\n",
       "      <td>1.291499</td>\n",
       "      <td>1.244084</td>\n",
       "      <td>1.244084</td>\n",
       "      <td>1.140353</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>[item_1, item_2, item_3]</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...</td>\n",
       "      <td>{'max_depth': 7, 'n_estimators': 10}</td>\n",
       "      <td>1.410147</td>\n",
       "      <td>1.410147</td>\n",
       "      <td>1.317691</td>\n",
       "      <td>1.277628</td>\n",
       "      <td>1.277628</td>\n",
       "      <td>1.172467</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     levels  \\\n",
       "0  [item_1, item_2, item_3]   \n",
       "1  [item_1, item_2, item_3]   \n",
       "2  [item_1, item_2, item_3]   \n",
       "3  [item_1, item_2, item_3]   \n",
       "4  [item_1, item_2, item_3]   \n",
       "5  [item_1, item_2, item_3]   \n",
       "6  [item_1, item_2, item_3]   \n",
       "7  [item_1, item_2, item_3]   \n",
       "\n",
       "                                                lags  \\\n",
       "0  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "1  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "2  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "3  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "4  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "5  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "6  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "7  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "\n",
       "                                          lags_label  \\\n",
       "0  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "1  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "2  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "3  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "4  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "5  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "6  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "7  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...   \n",
       "\n",
       "                                 params  \\\n",
       "0  {'max_depth': 7, 'n_estimators': 20}   \n",
       "1  {'max_depth': 3, 'n_estimators': 20}   \n",
       "2  {'max_depth': 7, 'n_estimators': 20}   \n",
       "3  {'max_depth': 3, 'n_estimators': 20}   \n",
       "4  {'max_depth': 7, 'n_estimators': 10}   \n",
       "5  {'max_depth': 3, 'n_estimators': 10}   \n",
       "6  {'max_depth': 3, 'n_estimators': 10}   \n",
       "7  {'max_depth': 7, 'n_estimators': 10}   \n",
       "\n",
       "   mean_absolute_scaled_error__weighted_average  \\\n",
       "0                                      0.896537   \n",
       "1                                      0.968697   \n",
       "2                                      0.970085   \n",
       "3                                      0.992591   \n",
       "4                                      1.295626   \n",
       "5                                      1.369425   \n",
       "6                                      1.378819   \n",
       "7                                      1.410147   \n",
       "\n",
       "   mean_absolute_scaled_error__average  mean_absolute_scaled_error__pooling  \\\n",
       "0                             0.896537                             0.891585   \n",
       "1                             0.968697                             0.946763   \n",
       "2                             0.970085                             0.962275   \n",
       "3                             0.992591                             0.971936   \n",
       "4                             1.295626                             1.213049   \n",
       "5                             1.369425                             1.292356   \n",
       "6                             1.378819                             1.291499   \n",
       "7                             1.410147                             1.317691   \n",
       "\n",
       "   root_mean_squared_scaled_error__weighted_average  \\\n",
       "0                                          0.873490   \n",
       "1                                          0.927639   \n",
       "2                                          0.930273   \n",
       "3                                          0.937760   \n",
       "4                                          1.172435   \n",
       "5                                          1.237487   \n",
       "6                                          1.244084   \n",
       "7                                          1.277628   \n",
       "\n",
       "   root_mean_squared_scaled_error__average  \\\n",
       "0                                 0.873490   \n",
       "1                                 0.927639   \n",
       "2                                 0.930273   \n",
       "3                                 0.937760   \n",
       "4                                 1.172435   \n",
       "5                                 1.237487   \n",
       "6                                 1.244084   \n",
       "7                                 1.277628   \n",
       "\n",
       "   root_mean_squared_scaled_error__pooling  max_depth  n_estimators  \n",
       "0                                 0.862816          7            20  \n",
       "1                                 0.896254          3            20  \n",
       "2                                 0.921523          7            20  \n",
       "3                                 0.910280          3            20  \n",
       "4                                 1.077139          7            10  \n",
       "5                                 1.143031          3            10  \n",
       "6                                 1.140353          3            10  \n",
       "7                                 1.172467          7            10  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grid search Multi-Series\n",
    "# ==============================================================================\n",
    "forecaster = ForecasterRecursiveMultiSeries(\n",
    "                 estimator = LGBMRegressor(random_state=123, verbose=-1),\n",
    "                 lags      = 24,\n",
    "                 encoding  = 'ordinal'\n",
    "             )\n",
    "\n",
    "lags_grid = [24, 48]\n",
    "param_grid = {\n",
    "    'n_estimators': [10, 20],\n",
    "    'max_depth': [3, 7]\n",
    "}\n",
    "\n",
    "cv = TimeSeriesFold(steps=24, initial_train_size=len(data_train), refit=False)\n",
    "\n",
    "levels = ['item_1', 'item_2', 'item_3']\n",
    "\n",
    "results = grid_search_forecaster_multiseries(\n",
    "              forecaster       = forecaster,\n",
    "              series           = data,\n",
    "              lags_grid        = lags_grid,\n",
    "              param_grid       = param_grid,\n",
    "              cv               = cv,\n",
    "              levels           = levels,  # Same as levels = None\n",
    "              metric           = ['mean_absolute_scaled_error', 'root_mean_squared_scaled_error'],\n",
    "              aggregate_metric = ['weighted_average', 'average', 'pooling'],\n",
    "          )\n",
    "\n",
    "results"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "skforecast_py12",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
